package paidaxing.blog.post.utils;

import paidaxing.blog.post.entity.Posts;
import paidaxing.blog.post.entity.Categories;
import paidaxing.blog.post.entity.Tags;
import paidaxing.blog.post.dto.PostDTO;
import paidaxing.blog.post.dto.CategoryDTO;
import paidaxing.blog.post.dto.TagDTO;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 文章模块实体与DTO转换工具类
 */
public class PostConverter {

    /**
     * 将Posts实体转换为PostDTO
     * 
     * @param posts 文章实体
     * @return 文章DTO
     */
    public static PostDTO toPostDTO(Posts posts) {
        if (posts == null) {
            return null;
        }

        PostDTO postDTO = new PostDTO();
        postDTO.setId(posts.getId());
        postDTO.setTitle(posts.getTitle());
        postDTO.setContent(posts.getContent());
        postDTO.setExcerpt(posts.getExcerpt());
        postDTO.setCoverImage(posts.getCoverImage());
        postDTO.setStatus(posts.getStatus());
        postDTO.setViewCount(posts.getViewCount());
        postDTO.setLikeCount(posts.getLikeCount());
        postDTO.setCommentCount(posts.getCommentCount());
        postDTO.setIsTop(posts.getIsTop());
        postDTO.setIsRecommend(posts.getIsRecommend());
        postDTO.setPassword(posts.getPassword());
        postDTO.setUserId(posts.getUserId());
        postDTO.setCategoryId(posts.getCategoryId());
        postDTO.setPublishedAt(posts.getPublishedAt());
        postDTO.setCreatedAt(posts.getCreatedAt());
        postDTO.setUpdatedAt(posts.getUpdatedAt());
        postDTO.setDeleted(posts.getDeleted());

        return postDTO;
    }

    /**
     * 将Categories实体转换为CategoryDTO
     * 
     * @param categories 分类实体
     * @return 分类DTO
     */
    public static CategoryDTO toCategoryDTO(Categories categories) {
        if (categories == null) {
            return null;
        }

        CategoryDTO categoryDTO = new CategoryDTO();
        categoryDTO.setId(categories.getId());
        categoryDTO.setName(categories.getName());
        categoryDTO.setSlug(categories.getSlug());
        categoryDTO.setDescription(categories.getDescription());
        categoryDTO.setParentId(categories.getParentId());
        categoryDTO.setOrderNum(categories.getOrderNum());
        categoryDTO.setPostCount(categories.getPostCount());
        categoryDTO.setCreatedAt(categories.getCreatedAt());
        categoryDTO.setUpdatedAt(categories.getUpdatedAt());
        categoryDTO.setDeleted(categories.getDeleted());

        return categoryDTO;
    }

    /**
     * 将Tags实体转换为TagDTO
     * 
     * @param tags 标签实体
     * @return 标签DTO
     */
    public static TagDTO toTagDTO(Tags tags) {
        if (tags == null) {
            return null;
        }

        TagDTO tagDTO = new TagDTO();
        tagDTO.setId(tags.getId());
        tagDTO.setName(tags.getName());
        tagDTO.setSlug(tags.getSlug());
        tagDTO.setDescription(tags.getDescription());
        tagDTO.setColor(tags.getColor());
        tagDTO.setPostCount(tags.getPostCount());
        tagDTO.setCreatedAt(tags.getCreatedAt());
        tagDTO.setUpdatedAt(tags.getUpdatedAt());
        tagDTO.setDeleted(tags.getDeleted());

        return tagDTO;
    }

    /**
     * 将PostDTO转换为Posts实体
     * 
     * @param postDTO 文章DTO
     * @return 文章实体
     */
    public static Posts toPosts(PostDTO postDTO) {
        if (postDTO == null) {
            return null;
        }

        Posts posts = new Posts();
        posts.setId(postDTO.getId());
        posts.setTitle(postDTO.getTitle());
        posts.setContent(postDTO.getContent());
        posts.setExcerpt(postDTO.getExcerpt());
        posts.setCoverImage(postDTO.getCoverImage());
        posts.setStatus(postDTO.getStatus());
        posts.setViewCount(postDTO.getViewCount());
        posts.setLikeCount(postDTO.getLikeCount());
        posts.setCommentCount(postDTO.getCommentCount());
        posts.setIsTop(postDTO.getIsTop());
        posts.setIsRecommend(postDTO.getIsRecommend());
        posts.setPassword(postDTO.getPassword());
        posts.setUserId(postDTO.getUserId());
        posts.setCategoryId(postDTO.getCategoryId());
        posts.setPublishedAt(postDTO.getPublishedAt());
        posts.setCreatedAt(postDTO.getCreatedAt());
        posts.setUpdatedAt(postDTO.getUpdatedAt());
        posts.setDeleted(postDTO.getDeleted());

        return posts;
    }

    /**
     * 将CategoryDTO转换为Categories实体
     * 
     * @param categoryDTO 分类DTO
     * @return 分类实体
     */
    public static Categories toCategories(CategoryDTO categoryDTO) {
        if (categoryDTO == null) {
            return null;
        }

        Categories categories = new Categories();
        categories.setId(categoryDTO.getId());
        categories.setName(categoryDTO.getName());
        categories.setSlug(categoryDTO.getSlug());
        categories.setDescription(categoryDTO.getDescription());
        categories.setParentId(categoryDTO.getParentId());
        categories.setOrderNum(categoryDTO.getOrderNum());
        categories.setPostCount(categoryDTO.getPostCount());
        categories.setCreatedAt(categoryDTO.getCreatedAt());
        categories.setUpdatedAt(categoryDTO.getUpdatedAt());
        categories.setDeleted(categoryDTO.getDeleted());

        return categories;
    }

    /**
     * 将TagDTO转换为Tags实体
     * 
     * @param tagDTO 标签DTO
     * @return 标签实体
     */
    public static Tags toTags(TagDTO tagDTO) {
        if (tagDTO == null) {
            return null;
        }

        Tags tags = new Tags();
        tags.setId(tagDTO.getId());
        tags.setName(tagDTO.getName());
        tags.setSlug(tagDTO.getSlug());
        tags.setDescription(tagDTO.getDescription());
        tags.setColor(tagDTO.getColor());
        tags.setPostCount(tagDTO.getPostCount());
        tags.setCreatedAt(tagDTO.getCreatedAt());
        tags.setUpdatedAt(tagDTO.getUpdatedAt());
        tags.setDeleted(tagDTO.getDeleted());

        return tags;
    }

    /**
     * 将标签实体列表转换为标签DTO列表
     * 
     * @param tagsList 标签实体列表
     * @return 标签DTO列表
     */
    public static List<TagDTO> toTagDTOList(List<Tags> tagsList) {
        if (tagsList == null) {
            return null;
        }

        return tagsList.stream()
                .map(PostConverter::toTagDTO)
                .collect(Collectors.toList());
    }

    /**
     * 将标签DTO列表转换为标签实体列表
     * 
     * @param tagDTOs 标签DTO列表
     * @return 标签实体列表
     */
    public static List<Tags> toTagsList(List<TagDTO> tagDTOs) {
        if (tagDTOs == null) {
            return null;
        }

        return tagDTOs.stream()
                .map(PostConverter::toTags)
                .collect(Collectors.toList());
    }
}